package com.power.service.impl;

import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.nacos.common.utils.CollectionUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.power.domain.Prod;
import com.power.domain.ProdTagReference;
import com.power.domain.Sku;
import com.power.mapper.ProdMapper;
import com.power.mapper.ProdTagReferenceMapper;
import com.power.service.ProdService;
import com.power.service.ProdTagReferenceService;
import com.power.service.SkuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
* @author dingchunlin
* @description 针对表【prod(商品)】的数据库操作Service实现
* @createDate 2024-07-10 15:12:14
*/
@Service
public class ProdServiceImpl extends ServiceImpl<ProdMapper, Prod> implements ProdService{

    @Autowired
    private ProdMapper prodMapper;

    @Autowired
    private ProdTagReferenceService prodTagReferenceService;

    @Autowired
    private SkuService skuService;

    @Autowired
    private ProdTagReferenceMapper prodTagReferenceMapper;


    /**
     * 保存商品信息
     * @param prod 商品信息
     * @return 是否保存成功
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean saveProd(Prod prod) {
        // 保存商品信息
        prod.setShopId(1L);
        prod.setSoldNum(0);
        prod.setCreateTime(new Date());
        prod.setUpdateTime(new Date());
        prod.setPutawayTime(new Date());
        prod.setVersion(0);
        Prod.DeliveryModeVo deliveryModeVo = prod.getDeliveryModeVo();
        prod.setDeliveryMode(JSONObject.toJSONString(deliveryModeVo));
        int insert = prodMapper.insert(prod);
        if (insert > 0) {
            // 处理商品与分组标签的关系
            Long prodId = prod.getProdId();
            // 获取商品分组标签
            List<Long> tagList = prod.getTagList();
            if (CollectionUtils.isNotEmpty(tagList) && tagList.size() != 0) {
                // 创建商品与标签的关系集合
                List<ProdTagReference> prodTagReferenceList = new ArrayList<>();
                // 遍历商品分组标签
                tagList.forEach(tagId -> {
                    ProdTagReference prodTagReference = new ProdTagReference();
                    prodTagReference.setProdId(prodId);
                    prodTagReference.setTagId(tagId);
                    prodTagReference.setCreateTime(new Date());
                    prodTagReference.setShopId(1L);
                    prodTagReference.setStatus(1);
                    prodTagReferenceList.add(prodTagReference);
                });
                // 批量插入商品与标签的关系
                prodTagReferenceService.saveBatch(prodTagReferenceList);
            }

            // 处理商品和sku的关系
            List<Sku> skuList = prod.getSkuList();
            if (CollectionUtils.isNotEmpty(skuList) && skuList.size() != 0) {
                // 循环遍历集合进行数据处理
                skuList.forEach(sku -> {
                    sku.setProdId(prodId);
                    sku.setCreateTime(new Date());
                    sku.setUpdateTime(new Date());
                    sku.setVersion(0);
                    sku.setActualStocks(sku.getStocks());
                });
                // 批量插入商品sku数据
                skuService.saveBatch(skuList);
            }

        }

        return insert > 0;
    }

    /**
     * 根据商品ID查询商品信息
     * @param prodId 商品ID
     * @return 商品信息
     */
    @Override
    public Prod loadProdByProdId(Long prodId) {
        // 查询商品信息
        Prod prod = prodMapper.selectById(prodId);
        if (ObjectUtil.isEmpty(prod)){
            return prod;
        }
        // 查询商品分组标签
        List<Long> tagList = prodTagReferenceService.selectTagIdByProdId(prodId);
        prod.setTagList(tagList);
        // 查询商品sku信息
        List<Sku> skuList = skuService.loadSkuByProdId(prodId);
        prod.setSkuList(skuList);
        return prod;
    }

    /**
     * 修改商品信息
     * @param prod 商品信息
     * @return 是否修改成功
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean modifyProdInfo(Prod prod) {
        // 获取商品ID
        Long prodId = prod.getProdId();
        // 删除原来的商品与标签的关系
        prodTagReferenceMapper.delete(new LambdaQueryWrapper<ProdTagReference>()
               .eq(ProdTagReference::getProdId, prodId));
        // 保存商品与标签的关系
        List<Long> prodTagList = prod.getTagList();
        if (CollectionUtils.isNotEmpty(prodTagList) && prodTagList.size() != 0) {
            List<ProdTagReference> prodTagReferenceList = new ArrayList<>();
            // 遍历商品分组标签
            prodTagList.forEach(tagId -> {
                ProdTagReference prodTagReference = new ProdTagReference();
                prodTagReference.setProdId(prodId);
                prodTagReference.setTagId(tagId);
                prodTagReference.setCreateTime(new Date());
                prodTagReference.setShopId(1L);
                prodTagReference.setStatus(1);
                prodTagReferenceList.add(prodTagReference);
            });
            // 批量插入商品与标签的关系
            prodTagReferenceService.saveBatch(prodTagReferenceList);
        }
        // 批量修改商品sku对象信息
        List<Sku> skuList = prod.getSkuList();
        skuList.forEach( sku -> {
            sku.setUpdateTime(new Date());
            sku.setActualStocks(sku.getStocks());
        });
        // 批量修改商品sku信息
        skuService.updateBatchById(skuList);
        // 修改商品信息
        prod.setUpdateTime(new Date());
        return prodMapper.updateById(prod) > 0;
    }

    /**
     * 单个/批量删除商品
     * @param prodIdList 商品ID列表
     * @return 是否删除成功
     */
    @Override
    public Boolean removeProdById(List<Long> prodIdList) {
        // 首先删除商品和标签的关系
        prodTagReferenceService.remove(new LambdaQueryWrapper<ProdTagReference>()
               .in(ProdTagReference::getProdId, prodIdList) );
        // 然后删除商品和sku的关系
        skuService.remove(new LambdaQueryWrapper<Sku>()
               .in(Sku::getProdId, prodIdList) );
        // 最后删除商品信息
        return prodMapper.deleteBatchIds(prodIdList) > 0;
    }

    /**
     * 根据分类ID查询商品列表
     *
     * @param categoryIdList 分类ID集合
     * @return 商品列表
     */
    @Override
    public List<Prod> queryProdListByCategoryIdList(List<Long> categoryIdList) {
        List<Prod> prodList = prodMapper.selectList(new LambdaQueryWrapper<Prod>()
                .in(Prod::getCategoryId, categoryIdList)
                .eq(Prod::getStatus, 1));
        return prodList;
    }

    /**
     * 根据商品ID查询微信端商品信息
     * @param prodId 商品ID
     * @return 微信端商品信息
     */
    @Override
    public Prod queryWxProdByProdId(Long prodId) {
        Prod prod = prodMapper.selectById(prodId);
        // 查询商品sku信息
        List<Sku> skuList = skuService.loadSkuByProdId(prodId);
        prod.setSkuList(skuList);
        return prod;
    }


}




